import { getNewCartGoods, mergeLocalCart, findCartList, insertCart, deleteCart, updateCart, checkAllCart } from '@/api/cart'
// 购物车模块

export default {
  state () {
    return {
      list: []
      // lit: [1, 2]

    }
  },
  getters: {
    // 有效商品列表
    validList (state) {
      // 有效商品库存大于1   有效标识为true

      return state.list.filter(goods => goods.stock > 0 || state.isEffective)
    },
    // 有效商品总件数
    validTotal (state, getters) {
      return getters.validList.reduce((p, c) => p + c.count, 0)
    },
    // 有效商品总金额
    validAmount (state, getters) {
      return getters.validList.reduce((p, c) => p + c.nowPrice * 100 * c.count, 0) / 100
    },
    // 无效商品列表
    invalidList (state) {
      return state.list.filter(goods => goods.stock <= 0 || !goods.isEffective)
    },
    // 已选商品列表
    selectedList (state, getters) {
      return getters.validList.filter(item => item.selected)
    },
    // 已选商品件数
    selectedTotal (state, getters) {
      return getters.selectedList.reduce((p, c) => p + c.count, 0)
    },
    // 已选商品总金额
    selectedAmount (state, getters) {
      return getters.selectedList.reduce((p, c) => p + Math.round(c.nowPrice) * 100 * c.count, 0) / 100
    },
    // 是否全选
    isCheckAll (state, getters) {
      return getters.validList.length !== 0 && getters.selectedList.length === getters.validList.length
    }
  },
  // 本地：id skuId name picture price nowPrice count attrsText selected stock isEffective
  // 线上：比上面多 isCollect 有用 discount 无用 两项项信息
  mutations: {
    // setlit (state, lit) {
    //   const lis=state.lit.findIndex(item => item.skuId === lit.skuId)
    // },

    insertCart (state, goods) {
      // const lit = state.list.skuId
      // console.log(state.list.findIndex(item => item.skuId === goods.skuId), 771)
      const sameIndex = state.list.findIndex(item => item.skuId === goods.skuId)

      // 逻辑：有相同的给goods累加数量，删除相同skuId的商品

      if (sameIndex > -1) {
        const count = state.list[sameIndex].count
        goods.count += count
        state.list.splice(sameIndex, 1)
      }

      state.list.unshift(goods)
    },
    // 修改购物车商品
    updateCart (state, goods) {
      // goods中字段有可能不完整，goods有的信息才去修改。
      // 1. goods中必需又skuId，才能找到对应的商品信息
      const updateGoods = state.list.find(item => item.skuId === goods.skuId)
      for (const key in goods) {
        if (goods[key] !== null && goods[key] !== undefined && goods[key] !== '') {
          updateGoods[key] = goods[key]
        }
      }
    },
    // 删除购物车商品
    deleteCart (state, skuId) {
      const index = state.list.findIndex(item => item.skuId === skuId)
      state.list.splice(index, 1)
    },
    // 设置购物车 （清空）
    setCart (state, payload) {
      // payload为空就清空 有值就设置
      state.list = payload
    }

  },
  actions: {

    //  加入购物车

    insertCart (ctx, goods) {
      return new Promise((resolve, reject) => {
        if (ctx.rootState.user.profile.token) {
        // 已登录 TODO
          insertCart({ skuId: goods.skuId, count: goods.count }).then(() => {
            return findCartList()
          }).then(data => {
            ctx.commit('setCart', data.result)
            resolve()
          })
        } else {
        // 未登录
          ctx.commit('insertCart', goods)

          resolve()
        }
      })
    },
    // 获取购物车列表
    findCartList (ctx) {
      return new Promise((resolve, reject) => {
        if (ctx.rootState.user.profile.token) {
          // 登录 TODO
          findCartList().then(data => {
            ctx.commit('setCart', data.result)
            resolve()
          })
        } else {
          // 本地
          // Promise.all() 可以并列发送多个请求，等所有请求成功，调用then
          // Promise.race() 可以并列发送多个请求，等最快的请求成功，调用then
          // 传参事promise数组
          const promiseArr = ctx.state.list.map(item => {
            // 返回接口函数的调用
            return getNewCartGoods(item.skuId)
          })
          Promise.all(promiseArr).then(dataArr => {
            dataArr.forEach((data, i) => {
              ctx.commit('updateCart', { skuId: ctx.state.list[i].skuId, ...data.result })
            })
            resolve()
          }).catch(e => {
            reject(e)
          })
        }
      })
    },
    // 删除购物城商品
    deleteCart (ctx, payload) {
      return new Promise((resolve, reject) => {
        if (ctx.rootState.user.profile.token) {
          deleteCart([payload]).then(() => {
            return findCartList()
          }).then(data => {
            ctx.commit('setCart', data.result)
            resolve()
          })
        } else {
          ctx.commit('deleteCart', payload)
          resolve()
        }
      })
    },
    // 修改购物车 选中状态 数量
    updateCart (ctx, payload) {
      // 必须要ckuId 可能有seleted count

      return new Promise((resolve, reject) => {
        if (ctx.rootState.user.profile.token) {
        // 已登录 TODO
          updateCart(payload).then(() => {
            return findCartList()
          }).then(data => {
            ctx.commit('setCart', data.result)
            resolve()
          })
        } else {
        // 未登录
          ctx.commit('updateCart', payload)

          resolve()
        }
      })
    },
    // 全选与取消全选
    checkAllCart (ctx, selected) {
      return new Promise((resolve, reject) => {
        if (ctx.rootState.user.profile.token) {
          const ids = ctx.getters.validList.map(item => item.skuId)
          checkAllCart({ selected, ids }).then(() => {
            return findCartList()
          }).then(data => {
            ctx.commit('setCart', data.result)
            resolve()
          })
        } else {
          ctx.getters.validList.forEach(goods => {
            ctx.commit('updateCart', { skuId: goods.skuId, selected })
          })
          resolve()
        }
      })
    },
    // 批量删除
    batchDeleteCart (ctx, isClear) {
      return new Promise((resolve, reject) => {
        if (ctx.rootState.user.profile.token) {
          // 已登录 TODO
          const ids = ctx.getters[isClear ? 'invalidList' : 'selectedList'].map(item => item.skuId)
          deleteCart(ids).then(() => {
            return findCartList()
          }).then(data => {
            ctx.commit('setCart', data.result)
            resolve()
          })
        } else {
          // 未登录
          // 找出选择的商品列表，遍历调用删除的mutations
          // isClear为true 时 删除失效商品列表，否则是选中的商品列表
          ctx.getters[isClear ? 'invalidList' : 'selectedList'].forEach(item => {
            ctx.commit('deleteCart', item.skuId)
          })

          resolve()
        }
      })
    },
    // 修改规格
    updateCartSku (ctx, { oldSkuId, newSku }) {
      return new Promise((resolve, reject) => {
        if (ctx.rootState.user.profile.token) {
          // 已登录 TODO
          // 找出旧的商品信息
          // 删除旧的商品信息
          // 根据新的sku信息和旧的sku信息合并成一条心的购物车商品信息
          // 添加新的商品
          const oldGoods = ctx.state.list.find(item => item.skuId === oldSkuId)
          deleteCart([oldGoods.skuId]).then(() => {
            return insertCart({ skuId: newSku.skuId, count: oldGoods.count })
          })
            .then(() => {
              return findCartList()
            }).then(data => {
              ctx.commit('setCart', data.result)
              resolve()
            })
        } else {
          // 未登录
          // 找出旧的商品信息
          // 删除旧的商品信息
          // 根据新的sku信息和旧的sku信息合并成一条心的购物车商品信息
          // 添加新的商品
          const oldGoods = ctx.state.list.find(item => item.skuId === oldSkuId)
          ctx.commit('deleteCart', oldSkuId)
          const { skuId, price: nowPrice, specsText: attrsText, inventory: stock } = newSku
          const newGoods = { ...oldGoods, skuId, nowPrice, attrsText, stock }
          ctx.commit('insertCart', newGoods)
          resolve()
        }
      })
    },
    // 合并购物车
    async mergeCart (ctx) {
      const cartList = ctx.state.list.map((goods) => {
        return {
          skuId: goods.skuId,
          selected: goods.selected,
          count: goods.count
        }
      })
      console.log('登录成功')
      await mergeLocalCart(cartList)

      //  清空本地购物车
      ctx.commit('setCart', [])
    }

  }
}
